			%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\documentclass[a4paper,11ptn]{report}                                   %
\usepackage[italian]{babel}                                             %
\usepackage{graphicx}                                                   %
\usepackage[colorlinks=true]{hyperref}                                  %
\usepackage{url}                                                        %
\usepackage{eurosym}                                                    %
\usepackage{lastpage}                                                   %
\usepackage{fancyhdr}                                                   %
\hypersetup{linkbordercolor=1 1 1}                                      %
\hypersetup{urlcolor=blue}                                              %
\hypersetup{linkcolor=black}                                            %
\graphicspath{{../immagini/}}                                           %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%



%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% 		COMPLETARE I CAMPI VUOTI PER LA GENERAZIONE AUTOMATICA			%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\newcommand{\Documento}{Definizione di Prodotto}                      % nome del documento
\newcommand{\Sommario}{Il presente documento contiene la definizione dell'architettura logica del sistema, con raffinamento della descrizione delle singole componenti.}               % sommario
\newcommand{\CodiceRevisione}{RQ}                                      % revisione (es. RPP)
\newcommand{\DataCreazione}{12 febbraio 2010}                    % data di creazione
\newcommand{\Versione}{0.3}                                                % versione attuale
\newcommand{\StatoDocumento}{Formale, Esterno}                % stato (es. Formale, Interno)
\newcommand{\Redazione}{Samuele Faggian}                      % autore del documento
\newcommand{\Revisione}{}                                               % verificatore del documento
\newcommand{\Approvazione}{Luca Zanini}                      % chi approva (responsabile)
\newcommand{\Committente}{Prof. Renato Conte, Prof. Tullio Vardanega}  % committente/i
\newcommand{\Proponente}{Dott. Claudio Palazzi}                         % proponente/i
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%



%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% 			IMPOSTAZIONE DEL DOCUMENTO (NON MODIFICARE)					%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\fancypagestyle{plain}{                                                 %
\fancyhf{}                                                              %
\fancyhead[L]{\Documento\ \Versione\ - \CodiceRevisione}                            %
\fancyfoot[C]{\thepage}                                                 %
\fancyhead[R]{\includegraphics[scale=0.3]{logoSevenSoft.png}}           %
}                                                                       %
\begin{document}                                                        %
\pagenumbering{Roman}                                                   %
\begin{center}                                                          %
\includegraphics[scale=0.8]{logoSevenSoft.png} \\                       %
\vspace*{1in}                                                           %
\huge{\textbf{\textbf{\Documento}}} \\                                  %
\vspace*{2cm}                                                           %
Versione: \Versione \\                                                  %
\vspace*{3cm}                                                           %
\vspace*{0.5in}                                                         %
\textbf{Sommario} \\                                                    %
\begin{normalsize}                                                      %
\Sommario                                                               %
\end{normalsize}                                                        %
\end{center}                                                            %
\newpage                                                                %
\thispagestyle{plain}                                                   %
\vspace*{0.5in}                                                         %
\begin{center}                                                          %
\begin{tabular}{l}                                                      %
\Large{\textbf{Capitolato: Simulatore File System}} \\                  %
\begin{tabular}{|p{5cm}|p{7cm}|}                                        %
\hline                                                                  %
\textbf{Data creazione:} &  \DataCreazione \\                            %
\hline                                                                  %
\textbf{Versione:} &  \Versione \\                                       %
\hline                                                                  %
\textbf{Stato del documento:} &  \StatoDocumento \\                      %
\hline                                                                  %
\textbf{Redazione:} &  \Redazione \\                                     %
\hline                                                                  %
\textbf{Revisione:} &  \Revisione  \\                                    %
\hline                                                                  %
\textbf{Approvazione:}  &  \Approvazione \\                              %
\hline                                                                  %
\textbf{Committente:} &  \Committente \\                                 %
\hline                                                                  %
\textbf{Proponente:} &  \Proponente \\                                   %
\hline                                                                  %
\end{tabular} \\                                                        %
\end{tabular}                                                           %
\end{center}                                                            %
                                                           %
                                                     %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%



%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% 		COMPLETARE I CAMPI VUOTI PER IL DIARIO DELLE MODIFICHE			%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\newpage
\thispagestyle{plain}
\begin{center}
\begin{tabular} {l}
\Large{\textbf{Legenda Diario delle modifiche}} \\
\begin{tabular}{|p{3cm}|p{7cm}|}
\hline
Vers & Versione del documento \\
\hline
Verif & Verificatore del documento \\
\hline
Resp & Responsabile che approva il documento \\
\hline
\hline
GB & Giuseppe Biolo \\
\hline
DDM & Daniele De Matteo \\
\hline
SF & Samuele Faggian \\
\hline
GF & Giuseppe Ferri \\
\hline
AL & Alberto Longato \\
\hline
AV & Alessandro Vedovato \\
\hline
LZ & Luca Zanini \\
\hline
\end{tabular} \\
\end{tabular}
\end{center}

\vspace*{2cm}

\begin{center}
\begin{tabular}{l}
\Large{\textbf{Diario delle modifiche}} \\
\begin{tabular}{|p{0.7cm}|p{1.9cm}|p{1.2cm}|p{1cm}|p{1cm}|p{6.9cm}|}
\hline
\textbf{Vers} & \textbf{Data} & \textbf{Autore} & \textbf{Verif} & \textbf{Resp} & \textbf{Descrizione} \\
\hline
0.7 & 04/06/2010 & GB & DDM & LZ& Varie modifiche per migliorare il documento, corretti errori vari
\hline
0.6 & 28/05/2010 & GB & DDM & LZ& Modifiche varie componenti Model,View, Controller
\hline
0.5 & 07/05/2010 & AV& DMM& LZ& Modifiche Model, aggiunto parti del controller e della view
\hline
0.4 & 03/05/2010 & AV& SF&LZ& Aggiunto component View\\
\hline
0.3 &  15/04/2010& GB& SF&AV& Aggiunte classi del component Controller, modifiche al component Model  \\
\hline
0.2 &  20/02/2010& VA& SF&GB& Modifiche, perfezionamenti e aggiunte classi del component Model  \\
\hline
0.1 &  11/02/2010 & GF& VA&GB& Prima stesura del documento, inserimento metodi classi principali e spiegazioni prime componenti  \\ 
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%



%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% 			IMPOSTAZIONE DEL DOCUMENTO (NON MODIFICARE)					%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\hline                                                                  %
\end{tabular}      \\                                                   %
\end{tabular}       \\                                                    %
\end{center}                                                            %
\newpage                                                                %
\tableofcontents                                                        %
\newpage                                                                %
\pagenumbering{arabic}                                                  %
\fancypagestyle{plain}{                                                 %
\fancyhf{}                                                              %
\fancyhead[L]{\Documento\ \Versione\ - \CodiceRevisione}                            %
\fancyfoot[C]{\thepage\ di \pageref{LastPage}}                          %
\fancyhead[R]{\includegraphics[scale=0.3]{logoSevenSoft.png}}           %
}                                                                       %
\pagestyle{plain}                                                       %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%



%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%	COMPLETARE I CAMPI VUOTI PER IL TESTO DEL DOCUMENTO (VEDI NORME)	%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\chapter{Introduzione}

\section{Scopo del documento}
Il presente documento si propone di fornire una descrizione completa dell'architettura logica prodotta al termine della fase di progettazione architetturale. Esso descrive in dettaglio le singole
componenti che costituiscono il prodotto.


\section{Scopo del prodotto}
SiFiSy costituir\`a  un simulatore di \underline{FS} che ha come obiettivo quello di mostrare agli studenti, ma in generale a qualunque utente interessato, il funzionamento e la logica di implementazione di diversi \underline{FS}, con la possibilit\`a  di confrontare le varie configurazioni scelte e condurre alcune analisi significative.\\

\section{Glossario}
Il glossario viene fornito in un documento separato denominato \textit{Glossario} che raccoglie le definizioni, acronimi ed abbreviazioni di tutta la documentazione. I termini presenti nel glossario verranno marcati nel documento con una sottolineatura.

\section{Riferimenti}
	
\subsection{Normativi}
Per i riferimenti normativi si faccia riferimento al documento \textit{normeDiProgetto.pdf} allegato.

\subsection{Informativi}
Per i riferimenti informativi di faccia riferimento ai seguenti documenti:
\begin{itemize}
	\item[] \textit{glossario.pdf}
	\item[] \textit{pianoDiProgetto.pdf}
\end{itemize}

\chapter{Standard di progetto}
\section{Standard di progettazione architetturale}
Per quanto riguarda le rappresentazioni grafiche dell'architettura del sistema
\textit{SIFISY} ci siamo basati sulle regole definite da UML 2.0. La scelta per la stesura di suddetti diagrammi UML \`e ricaduta su Bouml 4.19.1, ed \`e stato utilizzato per:
\begin{itemize}
	\item Diagrammi Use-Case in fase di Analisi
	\item Diagrammi delle classi, di attivit\`a, di sequenza in fase di Progettazione.
\end{itemize}
La scelta \`e motivata dalla diffusione e dall'utilizzo consolidato di tale linguaggio in contesti produttivi.


\section{Standard di documentazione del codice}
Il team SevenSoft si avvarr\`a dello strumento JavaDoc specifico per il linguaggio Java utilizzato che consente di creare la documentazione necessaria per la comprensione del codice consultabile in pagine HTML.
Per una pi\`u precisa comprensione dello strumento si faccia riferimento al documento \textit{normeDiProgetto.pdf} allegato.

\section{Standard di denominazione di entit\`a e relazioni}
essendo determinante per la comprensione del flusso logico dell'applicazione dovranno essere usati nomi significativi e altre convenzioni specifiche del linguaggio.
Per ulteriori chiarimenti si rimanda al documento \textit{normeDiProgetto.pdf} allegato.

\section{Standard di programmazione}
Le regole di programmazione sono ampiamente descritte nel documento \textit{normeDiProgetto.pdf} allegato. Quindi si rimanda nuovamente ad esso per ulteriori dettagli.

\section{Strumenti di lavoro}
I seguenti strumenti verranno impiegati:
\begin{itemize}
\item NetBeans IDE 6.8: per la stesura del codice Java
\item Matis: per la creazione grafica della GUI
\item \LaTeX\ per la stesura dei documenti
\item JUnit: per i test di unit\`a
\item Javadoc: per la documentazione del codice
\end{itemize}

\section{Pattern}
All'interno dell'architettura di sistema sono stati utilizzati i seguenti pattern, alcuni resi disponibili direttamente dal linguaggio Java:

\paragraph{MVC} Il \underline{pattern} MVC (Model View Controller) si basa sulla separazione
tra i componenti software del sistema, che gestiscono il modo in cui
presentare i dati, e i componenti che gestiscono i dati stessi.
\paragraph{Observer} Il \underline{pattern} Observer fornisce un'interfaccia di notifica per gli oggetti a cui devono essere notificati i cambiamenti di stato di un determinato oggetto osservato.
\paragraph{Command}
Specifica un'interfaccia per l'esecuzione di un'operazione generica: in questo modo incapsula una richiesta all'interno della sua istanza concreta ConcreteCommand, consentendo la parametrizzazione degli utenti con diverse tipologie di richieste. Il Concrete command definisce un legame fra un gestore e un'azione e implementa il metodo Execute invocando il metodo (o i metodi) corrispondente sul gestore associato: in tal modo disaccoppia l'oggetto che invoca una richiesta, dall'oggetto che possiede le informazioni per portarla a termine.
\paragraph{Fa\c{c}ade}
Consente attraverso un'interfaccia semplice, l'accesso a sottosistemi che espongono interfacce complesse e molto diverse tra loro, nonch\`e a blocchi di codice complessi.

\chapter{Specifica delle componenti}
Il sistema \textit{SIFISY} \`e basato sul pattern MVC, descriveremo qui di seguito le componenti. Verranno indicati l'elenco di attributi con la loro descrizione e i metodi con relativa descrizione sotto forma tabellare, nel quale si avr\`a, oltre alla descrizione, il nome del metodo con relativi eventuali parametri richiesti seguito dal valore restituito dal metodo. Esempio: \texttt{metodo(int parametro) : void}.
 \newpage
\section{Component Model}
Contiene una classe \texttt{Model} che contiene le simulazioni e i progetti attivi in un determinato momento nell'applicazione. Esegue i calcoli riguardanti simulazioni e progetti e notifica alla View eventuali cambiamenti di stato. Un'istanza di una particolare simulazione o progetto \`e associato a un file XML, potrebbe essere un file precedentemente salvato oppure un file di default che carica dati fissati dal sistema secondo alcuni criteri.
Di seguito sar\`a riportata un'immagine della struttura del componente Model e la descrizione di ogni singola classe.

\begin{figure}[h]
\centering
\includegraphics[scale=0.4]{generaleModel.png}
\caption{Diagramma delle classi semplificato del componente Model}
\end{figure}

\newpage
\subsection{File}
Classe che simula un vero e proprio file inserito dentro la partizione nel quale si vuole simulare il funzionamento del \underline{FS}.

\begin{figure}[h]
\centering
\includegraphics[scale=0.75]{file.png}
\caption{Diagramma delle classi semplificato di Simulation.java}
\end{figure}

\paragraph{Attributi}
Tutti gli attributi della classe hanno visibilit\`a \texttt{private}
\begin{itemize}
	\item[]\textbf{id:} attributo di tipo stringa per l'identificazione di un oggetto \underline{file}
	\item[]\textbf{dimension:} attributo intero che contiene il riferimento numerico della grandezza del \underline{file}. Esempio: se il \underline{file} \`e grande 10 MB, l'attributo contiene il numero 10
	\item[]\textbf{exponent:} attributo intero che contiene l'esponente della potenza di 2 che identifica l'unit\`a di misura del \underline{file} (Byte, KB, MB, GB, TB)
	\item[]\textbf{averageBlocks:} attributo di tipo long che contiene la media dei blocchi del \underline{file} salvati in modo contiguo
	\item[]\textbf{size:} attributo di tipo long che contiene la grandezza del \underline{file} in Byte
	\item[]\textbf{selectedAdvanced:} attributo di tipo boolean che viene settato a \textsf{true} se l'utente decide di calcolare anche il tempo medio di lettura dei file presenti nella simulazione
\end{itemize}
	
\paragraph{Metodi}
Questa classe \`e semplicemente una classe che simula un vero file. Il suo scopo \`e quello di contenere le informazioni su \underline{file} fittizzi che vengono usati nella simulazione, non contiene particolari metodi se non i metodi per accedere agli attributi o modificarli. Questi metodi non verranno descritti in quanto il loro funzionamento \`e banale. L'unico metodo che fa dei calcoli \`e:\\
\\
getSize() : long, che resituendo un long identifica la dimensione in Byte del file.

\subsection{Section}
Classe che simula un frammento contiguo di un \underline{file}. Un file \`e composto da uno o pi\`u frammenti (Section).

\begin{figure}[h]
\centering
\includegraphics[scale=0.75]{section.png}
\caption{Diagramma delle classi semplificato di Simulation.java}
\end{figure}

\paragraph{Attributi}
Tutti gli attributi della classe hanno visibilit\`a \texttt{private}
\begin{itemize}
	\item[]\textbf{id:} attributo di tipo stringa per l'identificazione il \underline{file} al quale il frammento appartiene
	\item[]\textbf{first:} attributo intero che contiene informazione su dove il primo blocco del frammento del \underline{file} \`e memorizzato
	\item[]\textbf{length:} attributo intero che contiene la lunghezza del frammento, insieme a \texttt{first} danno tutte le informazioni necessarie per sapere esattamente dov'\`e allocato in memoria il frammento di \underline{file}
\end{itemize}
\paragraph{Metodi}
Anche questa classe \`e semplicemente una classe che simula un frammento di file presente in memoria. Il suo scopo \`e semplicemente quello di contenere le informazioni riguardanti un determinato frammento di \underline{file} fittizzio.La classe non contiene particolari metodi se non i metodi per accedere agli attributi o modificarli. Questi metodi non verranno descritti in quanto il loro funzionamento \`e banale.


\newpage
\subsection{Simulation}
Classe astratta che identifica una \underline{simulazione} nel sistema \textit{SIFISY}.
\begin{figure}[h]
\centering
\includegraphics[scale=0.61]{simulation.png}
\caption{Diagramma delle classi semplificato di Simulation.java}
\end{figure}

\paragraph{Attributi}
Tutti gli attributi hanno visibilit\`a \texttt{private} se non specificato diversamente nella descrizione.
\begin{itemize}
	\item[]\textbf{simName:} attributo di tipo stringa che identifica univocamente la simulazione
	\item[]\textbf{files:} vettore di oggetti \texttt{File} contenuti nella simulazione. Visibilit\`a package
	\item[]\textbf{usedBlocks:} vettore di oggetti \texttt{Section} che contiene i blocchi occupati della partizione. Visibilit\`a package
	\item[]\textbf{partitionDimension:} attributo intero che contiene il riferimento numerico della grandezza della partizione. Esempio: se la partizione \`e grande 20 GB, partitionDimension contiene il numero 20
	\item[]\textbf{partitionExponent:} attributo intero che contiene l'esponente della potenza di 2 che identifica l'unit\`a di misura della partizione (Byte, KB, MB, GB, TB)
	\item[]\textbf{blockDimension:} attributo intero che contiene il riferimento numerico della grandezza del blocco. Esempio: se il blocco \`e grande 10 KB, blockDimension contiene il numero 10
	\item[]\textbf{blockExponent:} attributo intero che contiene l'esponente della potenza di 2 che identifica l'unit\`a di misura del blocco (Byte, KB, MB, GB, TB)
	\item[]\textbf{addressDimension:} attributo intero che identifica il numero di byte necessari a indirizzare un blocco in memoria
	\item[]\textbf{fileAllocationType:} attributo intero che identifica la politica di allocazione che il \underline{FS} utilizza: First Fit, Best Fit, Worst Fit, Next Fit
	\item[]\textbf{allocationNextIndex:} attributo intero utilizzato per la politica di allocazione Next Fit che tiene traccia dell'ultimo file inserito
	\item[]\textbf{rotationSpeed:} attributo intero che identifica un'ipotetica velocit\`a di rotazione del disco sul quale risiede il \underline{FS}
	\item[]\textbf{trackPercent:} attributo intero che identifica il numero di blocchi risiedenti nella stessa traccia
	\item[]\textbf{seekTime:} attributo intero che identifica il tempo di posizionamento della testina sulla traccia desiderata
	\item[]\textbf{trackSectors:} attributo intero che identifica il numero di settori per traccia
	\item[]\textbf{maxLenghtFile:} attributo intero che identifica il file di dimensione massima che si pu\`o memorizzare il un certo \underline(FS).
	\item[]\textbf{internalFragmentation:} attributo double che identifica la media della frammentazione interna dei file del disco
	\item[]\textbf{inflationIndex:} attributo double che identifica l'indice inflattivo medio dei file contenuti in una silìmulazione
	\item[]\textbf{averageReading:} attributo intero che identifica il tempo medio di lettura di un file da disco
	\item[]\textbf{sizeFileSystem:} attributo intero che identifica la dimensione del file system utilizzato per la simulazione
	\item[]\textbf{modifiedCamps:} attributo booleano che tiene traccia se ci son state modifiche nella simulazione per eventuali salvataggi
	\item[]\textbf{chooseAdvanced:} attributo booleano che identifica la scelta di inserire i dati per le opzioni avanzate, cio\`e per il calcolo del tempo medio di lettura
\end{itemize}

\paragraph{Metodi}
Illustriamo di seguito i metodi della classe. Ogni variabile privata indicata sopra avr\`a i suoi rispettivi metodi pubblici per modificarla e leggerla. Non andremo a descriverli in quanto il loro funzionamento \`e banale.
\begin{center}
\begin{tabular}{|p{5cm}|p{6.4cm}|}
\hline
\textbf{Nome} & \textbf{Descrizione}\\
\hline
save(Element simulationRoot) : void 		& Metodo pubblico che salva nel file XML corrispondente i dati della simulazione\\
\hline
single(Section item) : void			& Metodo pubblico che viene utilizzato per l'inserimento di una parte di file calcolando dove inserirlo in modo da creare frammentazione\\
\hline
insParts(Section section) : void		& Metodo pubblico che richiama la giusta politica di allocazione di un file per inserirne una parte\\
\hline
calculateRandomSpace() : long		& Metodo pubblico che calcola uno spazio casuale per simulare la frammentazione all'interno di un \underline{FS}\\
\hline
start()	: void					& Metodo pubblico astratto che verr\`a implementato nelle sottoclassi di Simulation\\
\hline
open(Element simulationRoot) : void 		& Metodo pubblico che carica i dati dall'XML riguardanti la classe Simulation\\
\hline
addFile(File item) : void			& Metodo pubblico per l'inserimento di un \underline{file} all'interno della simulazione e richiama il metodo di frammentazione del \underline{file}\\
\hline
breakFile(File item) : void			& Metodo pubblico che spezza il \underline{file} in frammenti di dimensione specificata dall'utente e richiama il metodo insPart(section)\\
\hline
deleteFile(String ID) : void			& Metodo pubblico per l'eliminazione di un determinato file dal vettore di file e richiama un metodo per la cancellazione dei frammenti\\
\hline
deleteParts(File item) : void			& Metodo pubblico per l'eliminazione dei frammenti di file presenti nel vettore usedBlocks\\
\hline
viewMaxFile()	: void				& Metodo pubblico astratto che verr\`a implementato nelle sottoclassi di Simulation\\
\hline
calculateAddressDimension() : void 		& Metodo pubblico per calcolare i byte di indirizzamento dei blocchi\\
\hline
\underline{getNearestTwoPow}(int address) : int& Metodo statico che restituisce la potenza di 2 pi\`u vicina al numero dato\\
\hline
\underline{getNearestExponentOfTwo}(double address) : int& Metodo statico che restituisce a cosa devo elevare 2 per ottenere il numero ricevuto in input\\
\hline
\end{tabular}
\begin{tabular}
{|p{5cm}|p{6.4cm}|}
\hline
calculateBlockNumber() : int			& Metodo pubblico per calcolare la quantit\`a di blocchi presenti nella partizione di disco utilizzata per la simulazione\\
\hline
fragAverage() : double			&Metodo per il calcolo della media della frammentazione interna\\
\hline
calculateFileFragmentation(long sizeFile) : double&Metodo di supporto a fragAverage che calcola la frammetazione interna di un singolo file\\
\hline
firstFit(Section item) : void 			& Metodo pubblico per simulare la politica di allocazione First Fit\\
\hline
bestFit(Section item) : void 			& Metodo pubblico per simulare la politica di allocazione Best Fit\\
\hline
worstFit(Section item) : void 			& Metodo pubblico per simulare la politica di allocazione Worst Fit\\
\hline
nextFit(Section item) : void 			& Metodo pubblico per simulare la politica di allocazione Next Fit\\
\hline
findSpace(int first, int last, int spaceNedded) : long& Metodo pubblico che cerca dove si pu\`o inserire un file all'interno della partizione con le politiche di allocazione\\
\hline
readingTime() : double			&Metodo che calcola il tempo medio di lettura di un file\\
\hline
\end{tabular}
\end{center}
%-----------sottoclassi simulation---------------------
%\newpage
\subsection{Ext2}
Classe che simula il comportamento del \underline{FS} Ext2.
\begin{figure}[h]
\centering
\includegraphics[scale=0.75]{ext2.png}
\caption{Diagramma delle classi semplificato di Ext2.java}
\end{figure}

\paragraph{Attributi}
Gli attributi della classe sono tutti privati.
\begin{itemize}
	\item[]\textbf{addressLevel:} contiene il livello di indirizzamento degli Inode, un diverso livello di indirizzamento consente il salvataggio di un file pi\`u o meno grande
	\item[]\textbf{firstInodeDirectBlock:} contiene il numero di blocchi del primo Inode che sono riservati alla memorizzazione dei dati
	\item[]\textbf{inodeDimension:} contiene la dimensione degli Inode del FS Ext2	
    	\item[]\textbf{inodeNumberMaxFile:} contiene il risultato del calcolo del numero di Inode necessari per il calcolo del file di dimensione massima
	\item[]\textbf{usedInodeNumber:} contiene il risultato del calcolo del numero di Inode necessari per un file

\end{itemize}
\paragraph{Metodi}
Illustriamo di seguito i metodi della classe. Ogni variabile privata indicata sopra avr\`a i suoi rispettivi metodi pubblici per modificarla e leggerla. Non andremo a descriverli in quanto il loro funzionamento \`e banale.

%TABELLA METODI EXT2
\begin{center}
\begin{tabular}{|p{5cm}|p{6.4cm}|}
\hline
\textbf{Nome} & \textbf{Descrizione}\\
\hline
save(Element simulationRoot) : void 		& Metodo pubblico che salva nel file XML corrispondente i dati della simulazione\\
\hline
getInodeNumber(long sizeFile) : long 		& Metodo pubblico che calcola in base alla dimensione in Byte del file quanti Inode servono per memorizzarlo nella partizione \\
\hline
calculateMaxFile() : int 			& Metodo pubblico che calcola il numero di blocchi massimo indirizzabili dalla struttura ad Inode di Ext2.\\
\hline
inflationIndex(long sizeFile) : double 		& Metodo pubblico che calcola l'indice inflattivo di un determinato file\\
\hline
inflactionIndexAverage() : double 		& Metodo pubblico che calcola la media dell'indice inflattivo di Ext2 nella partizione di disco utilizzata prendendo l'indice inflattivo dei singoli file memorizzati\\
\hline
fileSystemDimension() : long 			& Metodo pubblico che calcola lo spazio che gli Inode occuperebbero in memoria\\
\hline
start() : void 					& Metodo pubblico che calcola i risultati di una simulazione di tipo Ext2: Massimo file memorizzabile, media indice inflattivo, numero di Inode massimo, dimensione del file system, media frammentazione interna, (numero Inode file scelto dall'utente) \\
\hline
open(Element simulationRoot) : void 		& Metodo pubblico che carica i dati dall'XML riguardanti la simulazione del tipo Ext2\\
\hline
viewMaxFile()	: void				& Metodo pubblico che calcola il file di grandezza massima memorizzabile nell'hard disk\\
\hline
\end{tabular}
\begin{tabular}{|p{5cm}|p{6.4cm}|}
\hline
getConfigurationValues() : Vector	& Metodo pubblico che ritorna i valori settati sotto forma di stringa per la component View\\
\hline
getResultsValues() : Vector	& Metodo pubblico che ritorna i risultati calcolati sotto forma di stringa per la component View\\
\hline
\end{tabular}
\end{center}
%FINE TABELLA %%%%%%%%%%%%%%%%%

\subsection{Fat32}
Classe che simula il comportamento del \underline{FS} Fat 32. 
\begin{figure}[h]
\centering
\includegraphics[scale=0.75]{fat.png}
\caption{Diagramma delle classi semplificato di Ext2.java}
\end{figure}
\paragraph{Attributi}
Gli attributi della classe sono tutti privati.
\begin{itemize}
	\item[] \textbf{records}: attributo di tipo double che identifica la lunghezza dei record presenti nella tabella della FAT32
	\item[] \textbf{sizeFileSystem}: attributo di tipo double che contiene la dimensione del file system FAT32
	\item[] \textbf{maxPartitionSize}: attributo di tipo long che contiene la dimensione massima di una partizione per il quale FAT 32 funziona.

\end{itemize}
\paragraph{Metodi}
Illustriamo di seguito i metodi della classe. Ogni variabile privata indicata sopra avr\`a i suoi rispettivi metodi pubblici per modificarla e leggerla. Non andremo a descriverli in quanto il loro funzionamento \`e banale.
%TABELLA METODI FAT
\begin{center}
\begin{tabular}{|p{5cm}|p{6.4cm}|}
\hline
\textbf{Nome} & \textbf{Descrizione}\\
\hline
open(Element simulationRoot) : void		&Metodo pubblico che carica i dati dall'XML riguardanti la simulazione del tipo Fat32 \\
\hline
save(Element simulationRoot) : void		&Metodo pubblico che salva nel file XML corrispondente i dati della simulazione\\
\hline
start() : void					& Metodo pubblico che calcola i risultati di una simulazione di tipo Fat32: media indice inflattivo, dimensione del file system, frammentazione interna, tempo medio lettura di un file\\
\hline
inflationIndex(long sizeFile) : double 		& Metodo pubblico che calcola l'indice inflattivo di un determinato file\\
\hline
getFileMaxSize() : double			& Metodo pubblico che restituisce la dimensione massima di un file all'interno del file system\\
\hline
getFat32Dim() : double			& Metodo pubblico che calcola lo spazio che la tabella della FAT occuperebbero in memoria\\
\hline
viewMaxFile()	: void				& Metodo pubblico che calcola il file di grandezza massima memorizzabile nell'hard disk\\
\hline
getConfigurationValues() : Vector	& Metodo pubblico che ritorna i valori settati sotto forma di stringa per la component View\\
\hline
getResultsValues() : Vector	& Metodo pubblico che ritorna i risultati calcolati sotto forma di stringa per la component View\\
\hline
\end{tabular}
\end{center}
%FINE TABELLA

\newpage %%%%%%%%%%%%%%%%%
\subsection{Ntfs}
Classe che simula il comportamento del \underline{FS} Ntfs.
\begin{figure}[h]
\centering
\includegraphics[scale=0.75]{ntfs.png}
\caption{Diagramma delle classi semplificato di Ntfs.java}
\end{figure}

\paragraph{Attributi}
Gli attributi della classe sono tutti privati.
\begin{itemize}
	\item[] \textbf{baseRecord:} attributo intero che contiene lo spazio necessario per l'indirizzamento dei blocchi nel record base
    	\item[] \textbf{extensionRecord:} attributo intero che contiene lo spazio necessario per l'indirizzamento dei blocchi nel record estensione
	\item[] \textbf{baseRecordCouples:} attributo intero che identifica il numero delle coppie inizio - lunghezza presenti nel record base
	\item[] \textbf{extensionRecordCouples:} attributo intero che identifica l numero delle coppie inizio - lunghezza presenti nel record estensione
	\item[] \textbf{recordsOccupied:} attributo di tipo long che contiene i record attualmente occupati per NTFS
\end{itemize}
\paragraph{Metodi}
Illustriamo di seguito i metodi della classe. Ogni variabile privata indicata sopra avr\`a i suoi rispettivi metodi pubblici per modificarla e leggerla. Non andremo a descriverli in quanto il loro funzionamento \`e banale.
%TABELLA METODI NTFS
\begin{center}
\begin{tabular}{|p{5cm}|p{6.4cm}|}
\hline
\textbf{Nome} & \textbf{Descrizione}\\
\hline
inflactionIndexAverage() : double 		& Metodo pubblico che calcola la media dell'indice inflattivo di ext2 nella partizione di disco utilizzata prendendo l'indice inflattivo dei singoli file memorizzati\\
\hline
fileSystemDimension() : int			& Metodo pubblico che calcola lo spazio che i record delle tabelle occuperebbero in memoria\\
\hline
start() : void					& Metodo pubblico che calcola i risultati di una simulazione di tipo NTFS: Massimo file memorizzabile, media indice inflattivo, dimensione del file system, media frammentazione interna, tempo medio di lettura dei file\\
\hline
getRecordsNumber(String id) : int		&Metodo pubblico che in base alla simulazione restituisce il numero di record che compongono il \underline{FS} di tipo NTFS\\
\hline
calculateAddress(long partDimension) : int	&Metodo pubblico che calcola quanti byte sono necessari per l'indirizzamento nella tabella del \underline{FS} di tipo NTFS\\
\hline
open(Element simulationRoot) : void		&Metodo pubblico che carica i dati dall'XML riguardanti la simulazione del \underline{FS} di tipo NTFS \\
\hline
save(Element simulationRoot) : void		&Metodo pubblico che salva nel file XML corrispondente i dati della simulazione\\
\hline
viewMaxFile()	: void				& Metodo pubblico che calcola il file di grandezza massima memorizzabile nell'hard disk\\
\hline
getConfigurationValues() : Vector	& Metodo pubblico che ritorna i valori settati sotto forma di stringa per la component View\\
\hline
getResultsValues() : Vector	& Metodo pubblico che ritorna i risultati calcolati sotto forma di stringa per la component View\\
\hline
\end{tabular}
\end{center}
%FINE TABELLA

%-----------END sottoclassi simulation-----------------
\newpage
\subsection{Project}
Classe che raccoglie e gestisce un insieme di \underline{simulazioni} nel sistema \textit{SIFISY} e che ne calcola il confronto sulla base delle simulazioni scelte dall'utente all'interno della classe project.

\begin{figure}[h]
\centering
\includegraphics[scale=0.75]{project.png}
\caption{Diagramma delle classi semplificato di Project.java}
\end{figure}

\paragraph{Attributi}
Gli attributi della classe sono tutti privati.
\begin{itemize}
	\item[] \textbf{name:} attributo stringa che contiene il nome del progetto
	\item[] \textbf{simulationsRef:} vettore di tipo \texttt{Integer} che contiene gli indici delle simulazioni presenti nel progetto
	\item[] \textbf{compare:} vettore di tipo \texttt{Integer} che contiene gli indici delle simulazioni presenti nel progetto che l'utente vuole confrontare tra loro
    	\item[] \textbf{modified:} attributo booleano che tiene traccia se \`e stato modificato o no il progetto
	\item[] \textbf{bestCompare:} vettore di tipo \texttt{Integer} che contiene gli indici delle simulazioni che hanno il miglior risultato in un determinato confronto (Esempio: minor frammentazione interna)
\end{itemize}
\paragraph{Metodi}
Illustriamo di seguito i metodi della classe. Ogni variabile privata indicata sopra avr\`a i suoi rispettivi metodi pubblici per modificarla e leggerla. Non andremo a descriverli in quanto il loro funzionamento \`e banale.
%TABELLA METODI Project
\begin{center}
\begin{tabular}{|p{5cm}|p{6.4cm}|}
\hline
\textbf{Nome} & \textbf{Descrizione}\\
\hline
numberOfSimulation() : int			& Metodo pubblico che ritorna il numero di simulazioni presenti vettore di simulazioni\\
\hline
save(Element projectRoot) : void		&Metodo pubblico che salva nel file XML corrispondente i dati del progetto\\
\hline
open(Element projectRoot) : void		&Metodo pubblico che carica i dati dall'XML riguardanti il progetto\\
\hline
addSimulation(Integer simulationId)() : void	& Metodo pubblico che aggiunge l'indice di una simulazione al vettore di simulazioni presente nella classe Project\\
\hline
importSimulation(String filePath) : int		& Metodo pubblico che importa una simulazione esistente nel progetto e ne ritorna l'indice\\
\hline
importSimulation(String filePath, SimulationPanel panel) : void & Metodo pubblico che importa una simulazione esistente nel progetto e notifica alla component View\\
\hline
removeSimulation(int simId)() : void		& Metodo pubblico che elimina l'indice di una simulazione dal vettore di indici presente nella classe Project\\
\hline
getSimulation(int simId) : Integer		& Metodo pubblico che ritorna l'indice di una determinata simulazione\\
\hline
addCompare(Integer SimId) : void		& Metodo pubblico che aggiunge l'indice di una simulazione al vettore di indici di simulazioni da confrontare\\
\hline
removeCompare(Integer simId) : void	& Metodo pubblico che rimuove un'indice dal vettore \textsf{compare}\\
\hline
compare() : void				&Metodo pubblico che richiama i metodi che effettuano il calcolo comparativo delle simulazioni\\
\hline
compareOverhead() : void			& Metodo pubblico che confronta le simulazioni in base all'indice inflattivo del file system e salva nel vettore \textsf{bestCompare} l'indice della simulazione con overhead minore\\
\hline
compareMaxLenghtFile() : void		& Metodo pubblico che confronta le simulazioni in base al file di dimensione massima che si pu\`o salvare e salva nel vettore \textsf{bestCompare} l'indice della simulazione con file di dimensione maggiore\\
\hline
\end{tabular}
\begin{tabular}{|p{5cm}|p{6.4cm}|}
\hline
compareFileSystem() : void			&Metodo pubblico che confronta le simulazioni in base alla dimensione del file system e salva nel vettore \textsf{bestCompare} l'indice della simulazione con file system minore\\
\hline
compareInternalFragmentation() : void	&Metodo pubblico che confronta le simulazioni in base alla frammentazione media dei file e salva nel vettore \textsf{bestCompare} l'indice della simulazione con file system minore\\
\hline
\end{tabular}
\end{center}
%FINE TABELLA

\newpage
\subsection{Model}
Classe che gestisce tutti i flussi in entrata al Component Model indirizzandoli correttamente per avere poi risultati corretti.

\begin{figure}[h]
\centering
\includegraphics[scale=0.695]{modelClass.png}
\caption{Diagramma delle classi semplificato di Model.java}
\end{figure}

\paragraph{Attributi}
Gli attributi della classe sono tutti privati.
\begin{itemize}
	\item[] \textbf{simulations:} vettore statico privato che contiene le simulazioni aperte dall'utente
	\item[] \textbf{project:} vettore statico privato che contiene i progetti aperti dall'utente
   	\item[] \textbf{language:} attributo statico e privato che contiene la lingua scelta dall'utente che dovr\`a essere caricata dai file XML.
	\item[] \textbf{schemaPath:} 
	\item[] \textbf{setupPath:} attributo statico, privato e costante che carica le impostazioni di default
	\item[] \textbf{guiTranslatePath:}
	\item[] \textbf{startupScreen:}
	\item[] \textbf{getHelpPath:}
	\item[] \textbf{defaultSimulationPath:}
	\item[] \textbf{changedSetup:}
\end{itemize}

\begin{center}
\begin{tabular}{|p{5cm}|p{6.4cm}|}
\hline
\textbf{Nome} & \textbf{Descrizione}\\
\hline
\underline{loadSetup} () : void & Metodo pubblico che carica la simulazione desiderata\\
\hline
\underline{saveSetup} () : void & Metodo pubblico che salva la simulazione selezionata\\
\hline
\underline{translate} (String message) : String & Metodo pubblico che traduce la stringa passata come parametro\\
\hline
\underline{help} (String message) : String & Metodo pubblico che traduce la stringa passata come parametro\\
\hline
\underline{newSimulation} (String name, SimulationPanel panel) : void & Metodo pubblico che crea una nuova simulazione e che la inserisce nel vettore di simulazioni\\
\hline
\underline{openSimulation} (String path, SimulationPanel panel) : void & Metodo pubblico che apre una simulazione esistente e la inserisce nel vettore di simulazioni\\
\hline
\underline{resetToDefault} (int simulationId, SimulationPanel panel) : void & Metodo pubblico che ricarica la simulazione di default\\
\hline
\underline{switchFileSystem} (int simulationId, String fileSystemType) : void & Metodo pubblico che cambia il tipo di file system della simulazione\\
\hline
\underline{saveSimulation} (int index, String path, SimulationPanel panel) : void & Metodo pubblico che salva la simulazione selezionata dall'utente\\
\hline
\underline{startSimulation} (int simId, SimulationPanel panel) : void & Metodo pubblico che richiama l'avvio della simulazione selezionata dall'utente\\
\hline
\underline{removeSimulation} (int simId, SimulationPanel panel) : void & Metodo che rimuove una simulazione dal vettore di simulazioni\\
\hline
\underline{exportSimulationPng} (String simPath, SimulationPanel panel) throws java.io.FileNotFoundException : void & Metodo pubblico che esporta in png i grafici e i risultati della simulazione\\
\hline
\underline{exportSimulationPdf} (String simPath, SimulationPanel panel) : void & Metodo pubblico che esporta in pdf i risultati della simulazione\\
\hline
\underline{newProject} (String name, ProjectPanel panel) : void & Metodo pubblico statico che crea un nuovo progetto e lo inserisce nel vector di progetti\\
\hline
\underline{addSimulation} (String simName, SimulationPanel panel, int projectId) : void & Metodo pubblico statico che crea una simulazione e la aggiunge al vettore di progetti\\
\hline
\underline{openProject} (String path, ProjectPanel panel) : void & Metodo pubblico statico che apre un progetto precedentemente salvato\\
\hline
\underline{saveProject} (int prjId, String path, ProjectPanel panel) : void & Metodo pubblico statico che salva un progetto nell'xml presente nel vettore di progetti\\
\hline
simCompare (String prjName, String sim1Name, String sim2Name) & Credo non serva\\
\hline
\end{tabular}
\end{center}

\section{Componente View}
Implementa l'interfaccia Observer ed estende la classe astratta Observable. \\
Contiene lo stato a cui il Controller, in quanto suo Observer, \`e interessato.  \\
Inoltra una notifica al Controller quando il proprio stato si modifica in seguito alle richieste dei client, le quali risultano opportunamente tradotte in transizioni verso il Controller, con l'utilizzo opportuno del pattern Command.  \\

Costruttore   \\
Deve essere fornito un costruttore che inizializzi tutti gli oggetti grafici e crei l'intera interfaccia grafica iniziale.
Il codice necessario per portare a termine questo compito \`e generato da NetBeans.
%-----------------CONTROLLER----------------------
\section{Componente Controller}
Memorizza un riferimento all'oggetto View.  \\
Contiene informazioni che devono essere costantemente sincronizzate con lo stato della View.  \\
Implementa l'interfaccia di notifica di Observer per mantenere il proprio stato consistente con quello della View.  \\
Definisce un'interfaccia comune per tutti i gestori del Model.  \\
Dichiara il metodo factory CreateElement, che restituisce un oggetto di tipo Model: in tal modo il Controller definisce un'interfaccia per creare oggetti, ma lascia alle sottoclassi la decisione del tipo di classe da istanziare (applicando quindi il Pattern Factory Method in veste di Creator).

\subsection{Controller}
Setta i messaggi di errore e rende disponibili alcune funzionalit\`a che permetto l'interfacciamento con il Model in modo semplice.

\paragraph{Attributi}
Gli attributi della classe sono tutti privati.
\begin{itemize}
	\item[] \textbf{model:} attributo di tipo Model che consente la comunicazione con il component Model dell'MVC. La classe Model funge da Fa\c{c}ade. L'attributo dev'essere accessibile in tutto il controller.
	\item[] \textbf{error:} attributo di tipo String visibile in tutto il controller, racchiude in s\`e le chiavi per identificare gli errori provenienti dall'input degli utenti
\end{itemize}

\paragraph{Metodi}
Le variabile indicate sopra avranno il loro metodo pubblici per leggerle. Non andremo a descriverli in quanto il loro funzionamento \`e banale.

\begin{center}
\begin{tabular}{|p{5cm}|p{6.4cm}|}
\hline
\textbf{Nome} & \textbf{Descrizione}\\
\hline
convertSize(String exponent) : void			& Metodo pubblico che ritorna il valore espresso in potenza di 2 di KB,MB,GB o TB\\
\hline
dimensionPow(int dimension, int indexPow) : long	& Metodo pubblico che converte la dimensione inserita dall'utente in Byte (Esempio: 2KB = 2048)\\
\hline
\end{tabular}
\end{center}

\paragraph{Classi Interne}
Illustriamo di seguito le classi interne utilizzate per la gestione di simulazioni e progetti. 
\begin{itemize}
	\item[] \textbf{openSimulation:} Classe pubblica che implementa ActionListener e si occupa dell'apetura di una simulazione precedentemente salvata. Contiene i metodi:
	%TABELLA METODI
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	actionPerformed (ActionEvent event) : void	&Metodo pubblico necessario per implementare la classe ActionListener che richiama la classe Model per aprire una determinata simulazione.\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA

	\item[] \textbf{saveSimulation:} Classe pubblica che implementa ActionListener e si occupa del salvataggio di una simulazione. Contiene i metodi:
	%TABELLA METODI TestDimPart
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	actionPerformed (ActionEvent event) : void	&Metodo pubblico necessario per implementare la classe ActionListener che richiama la classe Model per salvare una determinata simulazione.\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA

	\item[] \textbf{openProject:} Classe pubblica che implementa ActionListener e si occupa dell'apetura di un progetto precedentemente salvata. Contiene i metodi:
	%TABELLA METODI
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	actionPerformed (ActionEvent event) : void	&Metodo pubblico necessario per implementare la classe ActionListener che richiama la classe Model per aprire un determinato progetto.\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA

	\item[] \textbf{saveProject:} Classe pubblica che implementa ActionListener e si occupa del salvataggio di un progetto. Contiene i metodi:
	%TABELLA METODI TestDimPart
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	actionPerformed (ActionEvent event) : void	&Metodo pubblico necessario per implementare la classe ActionListener che richiama la classe Model per salvare un determinato progetto.\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA
\end{itemize}

\subsection{SimulationManager}
Estende il Controller.  \\
Conosce il modo di svolgere le operazioni associate ad una richiesta relativa ad una simulazione singola del file system appropriato.
Come tutte le istanze concrete del Controller, corrisponde al Receiver nel Pattern Command.  \\
Sovrascrive il Factory Method CreateElement in modo da restituire un'istanza concreta del Model appropriata (in tal caso un oggetto specifico Simulation).

\paragraph{Attributi}
Gli attributi della classe sono tutti privati.
\begin{itemize}
	\item[] \textbf{existError:} vettore di \texttt{boolean} che tiene traccia degli errori presenti in vista
	\item[] \textbf{panel:} attributo di tipo \texttt{SimulationPanel} che contiene il riferimento della componente della vista propria della gestione di simulazione 
	\item[] \textbf{simId:} attributo intero che identifica l'indice della simulazione nel Vector presente nella classe Model
	\item[] \textbf{busySpace:} attributo di tipo \texttt{long} che identifica l'occupazione del disco per l'inserimento di più file
\end{itemize}

\paragraph{Metodi}
La variabile simulationName indicata sopra avr\`a il suo metodo pubblici per leggerla. Non andremo a descriverli in quanto il loro funzionamento \`e banale.

\begin{center}
\begin{tabular}{|p{5cm}|p{6.4cm}|}
\hline
\textbf{Nome} & \textbf{Descrizione}\\
\hline
writeError() : void		& Metodo pubblico che comunica alla vista eventuali errori presenti \\
\hline
startSimulation() : void	&Metodo pubblico che richiama il Model per effettuare l'avvio della simulazione con i dati inseriti dall'utente\\
\hline
dimPart() : void		& Metodo pubblico che controlla che la dimensione della partizione sia valida\\
\hline
dimBlock() : void		& Metodo pubblico che controlla che la dimensione del blocco sia valida\\
\hline
dimFile() : void			& Metodo pubblico che controlla che la dimensione del file sia valida\\
\hline
dimMultiFile() : void		&Metodo pubblico che controlla che la dimensione del file in modalit\`a inserimento multiplo sia valida\\
\hline
setFreeSpace() : void		& Metodo pubblico che comunica alla View la massima dimensione di un file inseribile con inserimento multiplo\\
\hline
testAddFile() : void		& Metodo pubblico che richiama il Model per l'inserimento di un file in modalit\`a multipla in una simulazione\\
\hline
testDeleteFile(String fileName, String fileValue) : void & Metodo pubblico che richiama il Model per l'eliminazione di un file in modalit\`a multipla in una simulazione\\
\hline
updateError() : void		& Metodo pubblico che al cambiare della modalit\`a di inserimento file azzera gli errori causati dall'utente in input della modalit\`a precedente\\
\hline
\end{tabular}
\begin{tabular}{|p{5cm}|p{6.4cm}|}
\hline
setBusySpace() : void		& Metodo pubblico che al caricamento di una simulazione da la possibilit\`a di aggiornare il campo dati busySpace \\
\hline
changeFileSystemType(String newType) : void		& Metodo pubblico che comunica al Model di cambiare il tipo di \underline{FS} per la simulazione \\
\hline
getExistError(int x) : boolean	& Metodo pubblico che comunica se l'errore di indice x \`e presente o meno nella simulazione \\
\hline
checkFile() : void		& Metodo pubblico che controlla se la variazione di un campo dati in comporta una non validit\`a del file inserito, in tal caso ne segnala un errore \\
\hline
validMultiFile() : boolean		& Metodo pubblico che verifica se il file inserito in modalit\`a multi file \`e valido (nome non gia presente nella simulazione e dimensioni coerenti con i dati inseriti) \\
\hline
setMaxFile(long maxLenght, String exp) : void		& Metodo pubblico che comunica alla View di aggiornare la lunghezza massima del file inseriti con i valori dati \\
\hline
\end{tabular}
\end{center}
%-------------------------INIZIO DESCRIZIONE CLASSI INTERNE--------------------------------
\paragraph{Classi Interne}
Illustriamo di seguito le classi interne utilizzate per la gestione di eventi catturati dalla vista. 
\begin{itemize}
	\item[] \textbf{TestDimPart:} Classe pubblica che implementa KeyListener e si occupa del controllo dei dati inseriti dall'utente riguardanti la dimensione della partizione. Contiene i metodi:
	%TABELLA METODI TestDimPart
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	keyPressed(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyTyped(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyReleased(KeyEvent event) : void			&Metodo pubblico che al rilascio di un pulsante dal campo dati riguardante la dimensione della partizione, effettua un controllo sul dato inserito e se corretto richiama il Model per salvarlo nella giusta simulazione\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA

	\item[] \textbf{TestComboDimPart:}  Classe pubblica che implementa ItemListener e cattura i cambiamenti di stato della componente combo box riguardante la dimensione della partizione espressa in KB, MB, GB o TB. Contiene i metodi:
	%TABELLA METODI TestComboMaxLivIndirizzamento
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	itemStateChanged(ItemEvent e) : void			&Metodo pubblico che al cambiamento della componente combo box riguardante la dimensione della partizione controlla la coerenza con la dimensione di un blocco e se coerente richiama il Model per salvare il dato nella giusta simulazione\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA

	\item[] \textbf{TestDimBlock:} Classe pubblica che implementa KeyListener e si occupa del controllo dei dati inseriti dall'utente riguardanti la dimensione dei blocchi della partizione. Contiene i metodi:
	%TABELLA METODI TestDimBlock
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	keyPressed(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyTyped(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyReleased(KeyEvent event) : void			&Metodo pubblico che al rilascio di un pulsante dal campo dati riguardante la dimensione del blocco, effettua un controllo sul dato inserito e se corretto richiama il Model per salvarlo nella giusta simulazione\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA

\item[] \textbf{TestComboDimBlock:} Classe pubblica che implementa ItemListener e cattura i cambiamenti di stato della componente combo box riguardante la dimensione di un blocco espressa in Byte, KB, MB o GB. Contiene i metodi:
	%TABELLA METODI TestComboDimBlock
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	itemStateChanged(ItemEvent e) : void			&Metodo pubblico che al cambiamento della componente combo box riguardante la dimensione di un blocco controlla la coerenza con la dimensione della partizione e se coerente richiama il Model per salvare il dato nella giusta simulazione\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA

	\item[] \textbf{TestDimFile:} Classe pubblica che implementa KeyListener e si occupa del controllo dei dati inseriti dall'utente riguardanti la dimensione di un unico file. Contiene i metodi:
	%TABELLA METODI TestDimFile
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	keyPressed(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyTyped(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyReleased(KeyEvent event) : void			&Metodo pubblico che al rilascio di un pulsante dal campo dati riguardante la dimensione del file, effettua un controllo sul dato inserito e se corretto richiama il Model per salvarlo nella giusta simulazione\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA
	
\item[] \textbf{TestComboDimFile:}  Classe pubblica che implementa ItemListener e cattura i cambiamenti di stato della componente combo box riguardante la dimensione di un file espressa in KB, MB, GB. Contiene i metodi:
	%TABELLA METODI TestComboDimFile
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	itemStateChanged(ItemEvent e) : void			&Metodo pubblico che al cambiamento della componente combo box riguardante la dimensione di un file controlla se il file è di dimensione adeguata per l'inserimento nella partizione e se coerente richiama il Model per salvare il dato nella giusta simulazione\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA

\item[] \textbf{TestDimMultiFile:} Classe pubblica che implementa KeyListener e si occupa del controllo dei dati inseriti dall'utente riguardanti la dimensione di un file in modalit\`a inserimento multiplo. Contiene i metodi:
	%TABELLA METODI TestDimFile
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	keyPressed(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyTyped(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyReleased(KeyEvent event) : void			&Metodo pubblico che al rilascio di un pulsante dal campo dati riguardante la dimensione del file, effettua un controllo sul dato inserito e se corretto richiama il Model per salvarlo nella giusta simulazione\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA

		
\item[] \textbf{TestComboDimMultiFile:}  Classe pubblica che implementa ItemListener e cattura i cambiamenti di stato della componente combo box riguardante la dimensione di un file in modalit\`a inserimento multiplo espressa in KB, MB, GB. Contiene i metodi:
	%TABELLA METODI TestComboDimFile
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	itemStateChanged(ItemEvent e) : void			&Metodo pubblico che al cambiamento della componente combo box riguardante la dimensione di un file controlla se il file è di dimensione adeguata per l'inserimento nella partizione e se coerente richiama il Model per salvare il dato nella giusta simulazione\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA

	\item[] \textbf{TestFragmentation:} Classe pubblica che implementa KeyListener e si occupa del controllo dei dati inseriti dall'utente riguardanti la frammentazione di un unico file espressa tramite il numero medio di blocchi contigui. Contiene i metodi:
	%TABELLA METODI TestFramm
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	keyPressed(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyTyped(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyReleased(KeyEvent event) : void			&Metodo pubblico che al rilascio di un pulsante dal campo dati riguardante il numero di blocchi contigui del file, effettua un controllo sul dato inserito e se corretto richiama il Model per salvarlo nella giusta simulazione\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA
	

	\item[] \textbf{TestDirectBlockFirstInode:} Classe pubblica che implementa KeyListener e si occupa del controllo del dati inserito dall'utente riguardante il numero di blocchi del primo i-node. Contiene i metodi:
	%TABELLA METODI TestBlockFirstInode
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	keyPressed(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyTyped(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyReleased(KeyEvent event) : void			&Metodo pubblico che al rilascio di un pulsante dal campo dati riguardante il numero di blocchi diretti del primo inode dell'Ext2, effettua un controllo sul dato inserito e se corretto richiama il Model per salvarlo nella giusta simulazione\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA

	\item[] \textbf{TestDimiNode:} Classe pubblica che implementa KeyListener e si occupa del controllo del dati inserito dall'utente riguardante la dimensione di un i-node. Contiene i metodi:
	%TABELLA METODI TestDimiNode
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	keyPressed(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyTyped(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyReleased(KeyEvent event) : void			&Metodo pubblico che al rilascio di un pulsante dal campo dati riguardante la dimensione dell'inode, effettua un controllo sul dato inserito e se corretto richiama il Model per salvarlo nella giusta simulazione\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA
	

	\item[] \textbf{TestComboFSType:} Classe pubblica che implementa ItemListener e cattura i cambiamenti di stato della componente combo box riguardante il tipo di \underline{FS}. Contiene i metodi:
	%TABELLA METODI TestComboTipoFS
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	itemStateChanged(ItemEvent e) : void			&Metodo pubblico che al cambiamento della componente combo box riguardante il tipo di \underline{FS}, effettua una conversione della simulazione e fa si che la vista si aggiorni con i campi dati propri del tipo di \underline{FS} selezionato\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA

	\item[] \textbf{TestComboMaxAddressLevel:} Classe pubblica che implementa ItemListener e cattura i cambiamenti di stato della componente combo box riguardante il massimo livello di indirizzamento degli i-node. Contiene i metodi:
	%TABELLA METODI TestComboMaxLivIndirizzamento
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	itemStateChanged(ItemEvent e) : void			&Metodo pubblico che al cambiamento della componente combo box riguardante il livello di indirizzamento degli i-node e richiama il Model per salvare il dato nella giusta simulazione\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA
	
	
	\item[] \textbf{TestRotationSpeed:} Classe pubblica che implementa KeyListener e si occupa del controllo del dati inserito dall'utente riguardante la velocit\`a di rotazione del disco. Contiene i metodi:
	%TABELLA METODI TestDimiNode
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	keyPressed(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyTyped(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyReleased(KeyEvent event) : void			&Metodo pubblico che al rilascio di un pulsante dal campo dati riguardante la velocit\`a di rotazione del disco, effettua un controllo sul dato inserito e se corretto richiama il Model per salvarlo nella giusta simulazione\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA
	

	\item[] \textbf{TestSeekTime:} Classe pubblica che implementa KeyListener e si occupa del controllo del dato inserito dall'utente riguardante il tempo di latenza del disco. Contiene i metodi:
	%TABELLA METODI TestDimiNode
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	keyPressed(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyTyped(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyReleased(KeyEvent event) : void			&Metodo pubblico che al rilascio di un pulsante dal campo dati riguardante il tempo di latenza del disco, effettua un controllo sul dato inserito e se corretto richiama il Model per salvarlo nella giusta simulazione\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA
	
	
	\item[] \textbf{TestTrack:} Classe pubblica che implementa KeyListener e si occupa del controllo del dato inserito dall'utente riguardante il numero di blocchi per traccia del disco. Contiene i metodi:
	%TABELLA METODI TestDimiNode
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	keyPressed(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyTyped(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyReleased(KeyEvent event) : void			&Metodo pubblico che al rilascio di un pulsante dal campo dati riguardanteil numero di blocchi per traccia del disco, effettua un controllo sul dato inserito e se corretto richiama il Model per salvarlo nella giusta simulazione\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA
		
	\item[] \textbf{TestMainRecord:} Classe pubblica che implementa KeyListener e si occupa del controllo del dato inserito dall'utente riguardante la dimensione del record base del file system NTFS. Contiene i metodi:
	%TABELLA METODI TestDimiNode
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	keyPressed(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyTyped(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyReleased(KeyEvent event) : void			&Metodo pubblico che al rilascio di un pulsante dal campo dati riguardante la dimensione del record base, effettua un controllo sul dato inserito e se corretto richiama il Model per salvarlo nella giusta simulazione\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA
	
	\item[] \textbf{TestExtensionRecord:} Classe pubblica che implementa KeyListener e si occupa del controllo del dato inserito dall'utente riguardante la dimensione del record di estensione del file system NTFS. Contiene i metodi:
	%TABELLA METODI TestDimiNode
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	keyPressed(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyTyped(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyReleased(KeyEvent event) : void			&Metodo pubblico che al rilascio di un pulsante dal campo dati riguardante la dimensione del record estensione, effettua un controllo sul dato inserito e se corretto richiama il Model per salvarlo nella giusta simulazione\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA
	
	\item[] \textbf{TestFileName:} Classe pubblica che implementa KeyListener e si occupa del controllo del dato inserito dall'utente riguardante il nome del file inserito. Contiene i metodi:
	%TABELLA METODI TestDimiNode
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	keyPressed(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyTyped(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyReleased(KeyEvent event) : void		&Metodo pubblico che al rilascio di un pulsante dal campo dati riguardante il nome del file, effettua un controllo sul dato inserito e se univoco richiama il Model per salvarlo nella giusta simulazione\\
	\hline
	
	\end{tabular}
	\end{center}
	%FINE TABELLA
	
	\item[] \textbf{TestComboAllocationType:} Classe pubblica che implementa ItemListener e cattura i cambiamenti di stato della componente combo box riguardante la politica di allocazione del file. Contiene i metodi:
	%TABELLA METODI TestComboAllocationType
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	itemStateChanged(ItemEvent e) : void			&Metodo pubblico che al cambiamento della componente combo box riguardante la politica di allocazione del file e richiama il Model per salvare il dato nella giusta simulazione\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA
	
	\item[] \textbf{TestSetAsDefault:} Classe pubblica che implementa ActionListener e imposta i valori settati dall'utente come simulazione di default 
	%TABELLA METODI testSetAsDefault
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	actionPerformed(ActionEvent event) : void			&Metodo pubblico che imposta i valori settati dall'utente come simulazione di default \\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA

	\item[] \textbf{resetToDefault:} Classe pubblica che implementa ActionListener e si occupa di richimare il Model per resettare la simulazione con i voli presenti nel default. Contiene i metodi:
	%TABELLA METODI resetToDefault
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	actionPerformed(ActionEvent event) : void			& Metodo pubblico che ripristina i valori della simulazione di default sulla simulazione attuale \\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA

	\item[] \textbf{showHideAdvancePannel:} Classe pubblica che implementa MouseListener e si occupa di nascondere/visualizzare la scermata a View del pannello avanzate. Contiene i metodi:
	%TABELLA METODI resetToDefault
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	mouseClicked(MouseEvent e) : void			& Metodo pubblico che nasconde/visualizza a View il pannello delle avanzate \\
	\hline
	mousePressed(MouseEvent e) : void 			&Metodo pubblico necessario per implementare la classe MouseListener ma non utilizzato nel sistema SiFiSy\\
        	\hline
 	mouseReleased(MouseEvent e) : void 			&Metodo pubblico necessario per implementare la classe MouseListener ma non utilizzato nel sistema SiFiSy\\
  	\hline
 	mouseEntered(MouseEvent e) : void 			&Metodo pubblico necessario per implementare la classe MouseListener ma non utilizzato nel sistema SiFiSy\\
  	\hline
 	mouseExited(MouseEvent e) : void 			&Metodo pubblico necessario per implementare la classe MouseListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA

	\item[] \textbf{startSimulation:} Classe pubblica che implementa ActionListener e si occupa di richimare il Model per calcolare i risultati di una simulazione. Contiene i metodi:
	%TABELLA METODI startSimulation
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	actionPerformed(ActionEvent event) : void			& Metodo pubblico che richiama il Model per avviare i calcoli per i risultati di una simulazione \\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA

	\item[] \textbf{resetToDefault:} Classe pubblica che implementa ActionListener e si occupa di richimare la View per cambiare i pannelli con i varii pampi dati per i diversi \underline{FS}. Contiene i metodi:
	%TABELLA METODI swichFileSystemPanel
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	actionPerformed(ActionEvent event) : void			& Metodo pubblico che cambia il pannello con il \underline{FS} desiderato\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA

\end{itemize}

\subsection{ProjectManager}
Estende il Controller.   \\
Conosce il modo di svolgere le operazioni associate ad una richiesta relativa ad un progetto (che \`e un insieme di simulazioni).
Come tutte le istanze concrete del Controller, corrisponde al Receiver nel Pattern Command.   \\
Sovrascrive il Factory Method CreateElement in modo da restituire un'istanza concreta del Model appropriata (in tal caso un oggetto specifico Project).

\paragraph{Attributi}
Gli attributi della classe sono tutti privati.
\begin{itemize}
	\item[] \textbf{panel:} attributo privato di tipo ProjectPanel che prende le informazioni contenute nella vista.
\end{itemize}

\paragraph{Metodi}
La variabile simulationName indicata sopra avr\`a il suo metodo pubblici per leggerla. Non andremo a descriverli in quanto il loro funzionamento \`e banale.

\begin{center}
\begin{tabular}{|p{5cm}|p{6.4cm}|}
\hline
\textbf{Nome} & \textbf{Descrizione}\\
\hline
ProjectManager(String projectName, ProjectPanel panel)	& costruttore della classe ProjectManager \\
\hline
addSimulation(int simulationId) : void			& Metodo pubblico che aggiunge la simulazione di indice simId al progetto\\
\hline
removeSimulation(int simulationId) : void		& Metodo pubblico che rimuove dal progetto la simulazione identificata da simId \\
\hline
importSimulation(String filePath) : int			& Metodo pubblico che aggiunge al progetto una simulazione precedentemente salvata (identificata dal proprio path di origine) e ne ritorna l'indice della simulazione \\
\hline
startCompare() : void					& Metodo pubblico che avvia il confronto tra simulazioni del progetto\\
\hline
addCompare(int simId) : void				& Metodo pubblico che aggiunge una simulazione alla lista delle simulazioni da comparare alla start \\
\hline
removeCompare(int simId) : void			& Metodo pubblico che rimuove una simulazione dalla lista delle simulazioni da comparare alla start \\
\hline
exportPdf(String filePath) : void			& Metodo pubblico che richiama l'esportazione in pdf del progetto\\
\hline
\end{tabular}
\end{center}

%\subsection{HelpManager}
%Estende il Controller.  \\
%Conosce il modo di svolgere le operazioni associate ad una richiesta relativa ad un file di tipo Help.  \\
%Come tutte le istanze concrete del Controller, corrisponde al Receiver nel Pattern Command.  \\
%Sovrascrive il Factory Method CreateElement in modo da restituire un'istanza concreta del Model appropriata (in tal caso un oggetto specifico Help).


%\paragraph{Attributi}
%Gli attributi della classe sono tutti privati.
%\begin{itemize}
%	\item[] \textbf{DA FARE:} DA FARE
%\end{itemize}

%\paragraph{Metodi}
%DA FARE

%\paragraph{Classi Interne}
%DA FARE

\subsection{PreferencesManager}
Estende il Controller. \\
Conosce il modo di svolgere le operazioni associate ad una richiesta relativa alle inpostazioni del sistema SiFiSy.  \\
Come tutte le istanze concrete del Controller, corrisponde al Receiver nel Pattern Command.  \\
Sovrascrive il Factory Method CreateElement in modo da restituire un'istanza concreta del Model appropriata (in tal caso un oggetto specifico Model).

\paragraph{Attributi}
Gli attributi della classe sono tutti privati.
\begin{itemize}
	\item[] \textbf{view:} attributo che contiene il riferimento della componente della vista propria della gestione delle impostazioni dell'applicativo SiFiSy
\end{itemize}

\paragraph{Metodi}
La classe non contiene metodi

\paragraph{Classi Interne}
Illustriamo di seguito le classi interne utilizzate per la gestione di eventi catturati dalla vista. 
\begin{itemize}
	\item[] \textbf{TestComboLanguage:} Classe pubblica che implementa ItemListener e si occupa del catturare l'azione dell'utente necessaria al cambiamento del linguaggio del sistema SiFiSy. Contiene i metodi:
	%TABELLA METODI TestComboLanguage
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	itemStateChanged(ItemEvent e) : void		&Metodo pubblico che cattura il cambiamento del linguaggio da parte dell'utente e comunica al Model di caricare il linguaggio selezionato\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA
\end{itemize}


\chapter{Appendice}

%\section{Codice sorgente?????????????}

\section{Tracciamento componenti - requisiti}
%Bene il tracciamento componenti � requisiti, ma manca il tracciamento inverso
\subsection{Package View}
\begin{center}
\begin{tabular}{l}
{\textbf{Package View}} \\
\begin{tabular}{|p{5.3cm}|p{7.0cm}|}
\hline
	\textbf{Componente} & \textbf{Requisito associato}\\
\hline
	View& FB01 - FB02 - FB03 - FB04 - FB05 - FB06 - FB07 - FB08 - FB09 - FB10 - FB11 - FB12 - FB13 - FB14 - FB15 - FD01 - FD02 - FD04 - FD05 - FD06 - FD07 - FD08 - FD09 - FD10 - FP01 - FP02 - FP03 - FP04 - PB01 - QB02 - QB03 - QP01 - QP02 - VB04\\
\hline
	Javax.swing& FB01 - FB02 - FB03 - FB04 - FB05 - FB06 - FB07 - FB08 - FB09 - FB10 - FB11 - FB12 - FB13 - FB14 - FB15 - FD01 - FD02 - FD04 - FD05 - FD06 - FD07 - FD08 - FD09 - FD10 - FP01 - FP02 - FP03 - FP04 - PB01 - QB02 - QB03 - QP01 - QP02 - VB04\\
\hline
\end{tabular}
\end{tabular}
\end{center}

\subsection{Package Controller}
\begin{center}
\begin{tabular}{l}
{\textbf{Package Controller}} \\
\begin{tabular}{|p{5.3cm}|p{7.0cm}|}
\hline
\textbf{Componente} & \textbf{Requisito associato}\\
\hline
Controller& FB08 - FB14 - FB15 - FD01 - FD05 - FD06 - FD07 - FD08 - FP01 - FD05 - QP02\\
\hline
EvenHandle& FB08 - FB14 - FB15 - FD01 - FD05 - FD06 - FD07 - FD08 - FP01 - FD05 - QP02\\
\hline
\end{tabular}
\end{tabular}
\end{center}

\subsection{Package Model}
\begin{center}
\begin{tabular}{l}
{\textbf{Package Model}} \\
\begin{tabular}{|p{5.3cm}|p{7.0cm}|}
\hline
	\textbf{Componente} & \textbf{Requisito associato}\\
\hline
	Model& FD09 - FD10\\
\hline
	Simulation& FB01 - FB02 - FB03 - FB04 - FB05 - FB06 - FB07 - FB08 - FB09 - FB10 - FB14 - FB15 - FP02 - FP03 - FP04 - VB03\\
\hline
	Project& FD01 - FD02 - FD03 - FD05 - FD06 - FD07 - FD08\\
\hline
	Help& QB02 - QP01 - VB04\\
\hline
\end{tabular}
\end{tabular}
\end{center}

\section{Tracciamento requisiti - componenti}

\subsection{Requisiti Funzionali}
\begin{center}
\begin{tabular}{l}
{\textbf{Requisiti Funzionali}} \\
\begin{tabular}{|p{3.0cm}|p{9.3cm}|}
\hline
	\textbf{Requisito} & \textbf{Componente associato}\\
\hline
	FB01& View - Javax.swing - Simulation\\
\hline
	FB02& View - Javax.swing - Simulation\\
\hline
	FB03& View - Javax.swing - Simulation\\
\hline
	FB04& View - Javax.swing - Simulation\\
\hline
	FB05& View - Javax.swing - Simulation\\
\hline
	FB06& View - Javax.swing - Simulation\\
\hline
	FB07& View - Javax.swing - Simulation\\
\hline
	FB08& View - Javax.swing - Simulation - Controller - EventHandler\\
\hline
	FB09& View - Javax.swing - Simulation\\
\hline
	FB10& View - Javax.swing - Simulation\\
\hline
	FB11& View - Javax.swing\\
\hline
	FB12& View - Javax.swing\\
\hline
	FB13& View - Javax.swing\\
\hline
	FB14& View - Javax.swing - Simulation - Controller - EventHandler\\
\hline
	FB15& View - Javax.swing - Simulation - Controller - EventHandler\\
\hline
	FD01& View - Javax.swing - Project - Controller - EventHandler\\
\hline
	FD02& View - Javax.swing - Project \\
\hline
	FD03& Project\\
\hline
	FD04& View - Javax.swing\\
\hline
	FD05& View - Javax.swing - Project - Controller - EventHandler\\
\hline
	FD06& View - Javax.swing - Controller - EventHandler\\
\hline
	FD07& View - Javax.swing - Controller - EventHandler\\
\hline
	FD08& View - Javax.swing - Controller - EventHandler\\
\hline
	FD09& View - Javax.swing\\
\hline
	FD10& View - Javax.swing\\
\hline
	FP01& View - Javax.swing - Simulation - Controller - EventHandler\\
\hline
	FD02& View - Javax.swing - Simulation\\
\hline
	FD03& View - Javax.swing - Simulation \\
\hline
	FD04& View - Javax.swing - Simulation\\
\hline
	FD05& Controller - EventHandler\\
\hline
\end{tabular}
\end{tabular}
\end{center}

\subsection{Requisiti Prestazionali}
\begin{center}
\begin{tabular}{l}
{\textbf{Requisiti Prestazionali}} \\
\begin{tabular}{|p{3.0cm}|p{9.3cm}|}
\hline
	\textbf{Requisito} & \textbf{Componente associato}\\
\hline
	PB01& View - Javax.swing\\
\hline
\end{tabular}
\end{tabular}
\end{center}

\subsection{Requisiti di qualit\`{a}}
\begin{center}
\begin{tabular}{l}
{\textbf{Requisiti di qualit\`{a}}} \\
\begin{tabular}{|p{3.0cm}|p{9.3cm}|}
\hline
	\textbf{Requisito} & \textbf{Componente associato}\\
\hline
	QB01&\\
\hline
	QB02& View - Javax.swing - Help\\
\hline
	QB03& View - Javax.swing\\
\hline
	QP01& Help\\
\hline
	QP02& View - Javax.swing - Controller - EventHandler\\
\hline
\end{tabular}
\end{tabular}
\end{center}

\subsection{Requisiti di vincolo}
\begin{center}
\begin{tabular}{l}
{\textbf{Requisiti di vincolo}} \\
\begin{tabular}{|p{3.0cm}|p{9.3cm}|}
\hline
	\textbf{Requisito} & \textbf{Componente associato}\\
\hline
	VB01& \\
\hline
	VB02&\\
\hline
	VB03& Simulation\\
\hline
	VB04& View - Javax.swing - Help\\
\hline
\end{tabular}
\end{tabular}
\end{center}

\end{document}                                                          